package com.net.framework.help.utils;

import android.content.Context;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//import org.codehaus.jackson.map.ObjectMapper;

/**
 * 字符串工具类
 */
public class StringUtil {

    /**
     * 去除字符串中所有空格
     */
    public static String remove(String resource) {
        StringBuffer buffer = new StringBuffer();
        int position = 0;
        char currentChar;

        while (position < resource.length()) {
            currentChar = resource.charAt(position++);
            if (currentChar != ' ')
                buffer.append(currentChar);
        }
        return buffer.toString();
    }

    public static String deNull(String str) {
        if (str == null) {
            return "";
        }
        return str;
    }

    public static String Object2String(Object obj) {
        if (obj == null) {
            return "";
        }
        return obj.toString();
    }

    /**
     * 功能描述：是否为空白,包括null和""
     *
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {
        return str == null || str.trim().length() == 0 || "null".equals(str);
    }

    public static String toHTML(String str) {
        if (null == str)
            return str;

        return str.replaceAll("\n", "<br\\>").replaceAll(" ", "&nbsp;");
    }

    /***
     * 半角转换为全角 可以一定程度上解决textview换行的问题
     *
     * @param input
     * @return
     */
    public static String ToDBC(String input) {

        if (input == null) {
            return "";
        }

        char[] c = input.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == 12288) {
                c[i] = (char) 32;
                continue;
            }
            if (c[i] > 65280 && c[i] < 65375)
                c[i] = (char) (c[i] - 65248);
        }
        return new String(c);
    }

    /**
     * 是否不为空
     *
     * @param s
     * @return
     */
    public static boolean isNotEmpty(String s) {
        return s != null && !"".equals(s.trim());
    }

    /**
     * 是否为空
     *
     * @param s
     * @return
     */
    public static boolean isEmpty(String s) {
        return s == null || "".equals(s.trim());
    }

    /**
     * 通过{n},格式化.
     *
     * @param src
     * @param objects
     * @return
     */
    public static String format(String src, Object... objects) {
        int k = 0;
        for (Object obj : objects) {
            src = src.replace("{" + k + "}", obj.toString());
            k++;
        }
        return src;
    }

    // public final static String toJson(Object object) {
    // String json_string = null;
    // try {
    // ObjectMapper mapper = new ObjectMapper();
    // json_string = mapper.writeValueAsString(object);
    // } catch (Exception e) {
    // json_string = null;
    // }
    // return json_string;
    // }

    public static boolean matcherRegex(String regex, String matchString) {
        Pattern pattern = Pattern.compile(regex);
        return pattern.matcher(matchString).matches();

    }


    /**
     * 判断是否为整数
     *
     * @param str
     * @return
     */
    public static boolean isDigits(String str) {
        return str.matches("[-+]?[0-9]*");
    }

    /**
     * 用ascii码
     */
    public static boolean isAsciiNumeric(String str) {
        for (int i = str.length(); --i >= 0; ) {
            int chr = str.charAt(i);
            if (chr < 48 || chr > 57)
                return false;
        }
        return true;
    }

    /***
     * 验证Email是否有效
     *
     * @param email
     * @return
     */
    public static boolean isEmailValid(String email) {
        String str = "^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)" + "|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
        Pattern p = Pattern.compile(str);
        Matcher m = p.matcher(email);
        return m.matches();
    }

    /**
     * 判断手机格式是否正确
     *
     * @param paramString
     * @return
     */
    public static boolean isMobileNO(String paramString) {
//        if (paramString == null)
//            return false;
//        return Pattern.compile("^1[3-9][0-9]{9}$").matcher(paramString).matches();
        if (paramString == null)
            return true;
        return paramString.length() != 11;
    }

    /***
     * 判断验证码是否正确（四位数的）
     *
     * @param veriCode
     * @return
     */
    public static boolean isVeriCode(String veriCode) {

        Pattern p = Pattern.compile("^\\d{6}$");
        Matcher m = p.matcher(veriCode);
        return m.matches();
    }

    /**
     * 验证是否为邮政编码
     */
    public static boolean isPostalServiceCode(String veriCode) {
        Pattern p = Pattern.compile("^[1-9]\\d{5}$");
        Matcher m = p.matcher(veriCode);
        return m.matches();
    }

    /****
     * 判断是否全是数字
     *
     * @param str
     * @return
     */
    public static boolean isNumeric(String str) {
        if (str == null || str.equals("")) {
            return true;
        }
        Pattern pattern = Pattern.compile("[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }

    /***
     * 检查电话号码、手机号码格式是否正确
     *
     * @param context
     * @param link_phone
     * @param msg
     * @return
     */
    public static boolean linkPhoneCheck(Context context, String link_phone, String msg) {
        // boolean bool =
        // Pattern.compile("^1[3-9][0-9]{9}$").matcher(link_phone).matches();//手机号码验证
        // p1 = Pattern.compile("^[0][1-9]{2,3}-[0-9]{5,10}$"); // 验证带区号的
        // p2 = Pattern.compile("^[1-9]{1}[0-9]{5,8}$"); // 验证没有区号的

        boolean bool = Pattern.compile("^(1[3-9][0-9]{9}|[0][1-9]{2,3}-[0-9]{5,8}|[0][1-9]{2,3}[0-9]{5,8}|[1-9]{1}[0-9]{5,8})$").matcher(link_phone).matches();// 手机号码验证

        if (!bool) {// 不通过
            UIUtils.shortToast(msg);
        }
        return bool;
    }

    /***
     * 验证输入的字符串是否符合要求（长短验证，在多少长度之内）
     *
     * @param str    需验证的字符串
     * @param length 字符串长度规格
     * @return true 验证通过，否则验证不通过
     */

    public static boolean lengthVerify(String str, int length) {
        if (str.length() <= length) {
            return true;
        }
        return false;
    }

    /***
     * 验证输入值是否符合要求
     *
     * @param str     需验证的字符串
     * @param minimum 最小值
     * @param maximum 最大值
     * @return true 验证通过，否则验证不通过
     */
    public static boolean sizeVerify(String str, int minimum, int maximum) {
        int current_value = str.length();
        if (current_value >= minimum && current_value <= maximum) {// 符合条件
            return true;
        }
        return false;
    }

    /***
     * 比较两个数值是否相等
     *
     * @param value1
     * @param value2
     * @return
     */
    public static boolean sizeCompare(String value1, String value2) {
        double Double1 = Double.valueOf(value1);
        double Double2 = Double.valueOf(value2);
        int Integer1 = (int) Double1;
        int Integer2 = (int) Double2;
        if (Integer1 == Integer2) {// 符合条件
            return true;
        }
        return false;
    }

    /***
     * 两个值是否相同
     *
     * @param value1
     * @param value2
     * @return
     */
    public static boolean isEqual(String value1, String value2) {
        if (value2.equals(value1)) {
            return true;
        }
        return false;
    }

    /**
     * 判断得到的图片地址是否为gif后缀
     *
     * @param uri
     * @return true：是GIF图片，否则不是
     */
    public static boolean isGif(String uri) {
        Pattern p = Pattern.compile("(?i).+?\\.(gif|Gif|GIF)");
        Matcher m = p.matcher(uri);
        return m.matches();
    }

    /***
     * 正则简单验证身份证是否有效
     */
    public static boolean isIDCard(String idcard) {
        Pattern p = Pattern.compile("([0-9]{17}([0-9]|X))|([0-9]{15})");
        Matcher m = p.matcher(idcard);
        return m.matches();
    }

    /***
     * 如果小数点后面为0，则去掉
     *
     * @param num
     * @return
     */
    public static String cancelZero(double num) {
        if (num % 1.0 == 0) {
            return String.valueOf((long) num);
        }
        return String.valueOf(num);
    }

    /***
     * 字符的截取
     */

    public static String cutOut(String string, String str_value) {
        if (string.startsWith(str_value))// 第一个字符为str_value字符
        {
            return string;
        } else {
            return string.substring(1, string.length());
        }
    }

    /***
     * 截取字符串中某两个字符之间的字符串
     *
     * @param content
     * @param str_start
     * @param str_end
     * @return
     */
    public static String cuttingBetween(String content, String str_start, String str_end) {
        String result = null;
        if (StringUtil.isBlank(str_start) && StringUtil.isBlank(str_end)) {
            result = content;
        } else if (!StringUtil.isBlank(str_start) && !StringUtil.isBlank(str_end)) {
            result = content.substring(content.indexOf(str_start) + str_start.length(), content.indexOf(str_end));
        } else if (StringUtil.isBlank(str_start) && !StringUtil.isBlank(str_end)) {
            result = content.substring(0, content.indexOf(str_end));
        } else if (!StringUtil.isBlank(str_start) && StringUtil.isBlank(str_end)) {
            result = content.substring(content.indexOf(str_start) + str_start.length(), content.length());
        }
        return result;
    }

    /***
     * 截取图片名称
     *
     * @param imgUrl 图片的网络地址
     * @return 图片名字
     */
    public static String getImgName(String imgUrl) {
        if (imgUrl == null) {
            return null;
        }
        String[] strs = imgUrl.split("/");
        String str_file = strs[strs.length - 1];// 得到图片的文件名
        String[] strs_name = str_file.split("\\.");// 得到文件名（去除格式）
        return strs_name[0];
    }

    /***
     * 隐藏手机号码的中间四位
     *
     * @param phone
     * @return
     */
    public static String secretPhone(String phone) {
        if (isBlank(phone)) {
            return "";
        } else {
            String secretResult = "";
            if (phone.length() <= 3) {
                secretResult = phone + "****";
            } else {
                Pattern p = Pattern.compile("(.{3})(.+)(.{4})");
                Matcher m = p.matcher(phone);
                secretResult = m.replaceAll("$1****$3");
            }
            return secretResult;

            // return phone.replace(phone.substring(3, 7), "****");
        }
    }

    /***
     * 隐藏身份证中间的位数
     *
     * @param idCard
     * @return
     */
    public static String secretIdCard(String idCard) {
        if (isBlank(idCard)) {
            return "";
        } else {
            return idCard.replaceAll("(\\d{6})\\d{8}(\\w{4})", "$1********$2");
        }
    }


    /**
     * 隐藏邮箱中间的字符，用“*”代替
     *
     * @return
     */
    public static String secretEmail(String email) {
        if (isBlank(email)) {
            return "";

        }
        Pattern p = Pattern.compile("(\\w{3})(\\w+)(\\w{3})(@\\w+)");
        Matcher m = p.matcher(email);
        return m.replaceAll("$1***$3$4");
    }

    /**
     * 替换字符中间位置的字符，以“*”代替
     */
    public static String secretString(String value) {
        String secretResult;
        if (isBlank(value)) {
            return "";
        }
        if (value.length() == 1) {
            secretResult = value + "***";
        } else {
            if (value.length() == 2) {
                value = insertStringInParticularPosition(value, "*", 1);
            }
            Pattern p = Pattern.compile("(.{1})(.+)(.{1})");
            Matcher m = p.matcher(value);
            secretResult = m.replaceAll("$1***$3");
        }
        return secretResult;
    }

    public static String insertStringInParticularPosition(String src, String dec, int position) {
        StringBuffer stringBuffer = new StringBuffer(src);
        return stringBuffer.insert(position, dec).toString();
    }

    /****
     * 截取字符串后四位
     */
    public static String cutLastFour(String value) {
        String last_fourDigit = null;
        // 若长度大于4位数，则截取后四位，如果没有四位则直接返回原卡号
        int length = value.length();
        if (length > 4) {
            last_fourDigit = value.substring(length - 4, length);
        } else {
            last_fourDigit = value;
        }
        return last_fourDigit;
    }

    /**
     * 去除字符串中指定的字符
     *
     * @param value 字符串
     * @param chars 指定要删除的字符
     * @return
     */
    public static String deleteChars(String value, String chars) {
        // 是否包含该字符
        if (value.contains(chars)) {
            return value.replace(chars, "");
        } else {
            return value;
        }
    }

    /***
     * 分割以","字符隔开的字符串数据，返回一个集合
     *
     * @return
     */
    public static List<String> getList(String str) {
        List<String> list = new ArrayList<>();
        if (!isBlank(str)) {
            String[] strArray = str.split(","); // 拆分字符为"," ,然后把结果交给数组strArray
            for (String string : strArray) {
                list.add(string);
            }
        }
        return list;
    }

    /***
     * 分割以"-"字符隔开的字符串数据，返回一个集合
     *
     * @return
     */
    public static List<String> getAgeList(String str) {
        List<String> list = new ArrayList<String>();
        if (!isBlank(str)) {
            String[] strArray = str.split("-"); // 拆分字符为"-" ,然后把结果交给数组strArray
            for (String string : strArray) {
                list.add(string);
            }
        }
        return list;
    }

    /***
     * 将list集合数据转化成已“,”隔开的字符串
     *
     * @param stringList
     * @return
     */
    public static String listToString(List<String> stringList) {
        if (stringList == null || stringList.size() == 0) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        boolean flag = false;
        for (String string : stringList) {
            if (flag) {
                result.append(",");
            } else {
                flag = true;
            }
            result.append(string);
        }
        return result.toString();
    }

    /***
     * 判断是否为网址
     *
     * @param value 需验证的字符串
     * @return
     */
    public static boolean isUrl(String value) {
        if (isBlank(value)) {
            return false;
        }
        Pattern pattern = Pattern.compile("(http|ftp|https)://(([a-zA-z0-9]|-){1,}\\.){1,}[a-zA-z0-9]{1,}-*");
        Matcher matcher = pattern.matcher(value);
        return matcher.find() ? true : false;
    }

    /***
     * 判断是否为字母
     *
     * @param str
     * @return
     */
    public static boolean isLetter(String str) {
        Pattern p = Pattern.compile("^[A-Za-z]+$");
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 是否包含英语字母
     *
     * @param str
     * @return
     */
    public static boolean isContainsLetter(String str) {
        Pattern p = Pattern.compile(".*[a-zA-z].*");
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 是否包含中文汉字
     *
     * @param str
     * @return
     */
    public static boolean isExistChinese(String str) {
        return str.getBytes().length != str.length();
    }

    /***
     * 验证是否为QQ
     */
    public static boolean isQQ(String str) {
        Pattern p = Pattern.compile("[1-9][0-9]{4,11}");
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 截取数据，取出字符串尾部的“,”
     */
    public static String interceptionString(String value) {
        if (!StringUtil.isBlank(value)) {
            if (value.substring(value.length() - 1, value.length()).equals(",")) {
                value = value.substring(0, value.length() - 1);
            }
        }
        return value;
    }

    /**
     * true是正数 ；false 是负数
     */
    public static boolean isPositiveNumber(String value) {
        Boolean strResult = value.matches("-?[0-9]+.*[0-9]*");
        return strResult;
    }

    /**
     * 验证是否为ip地址
     *
     * @return true是ip，false不是ip
     */
    public static boolean isIP(String matchString) {
        Pattern pattern = Pattern.compile("\\b((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\b");
        return pattern.matcher(matchString).matches();

    }

    /**
     * 验证是否为端口
     *
     * @return true是端口，false不是端口
     */
    public static boolean isPort(String matchString) {
        Pattern pattern = Pattern.compile("/^[1-9]$|(^[1-9][0-9]$)|(^[1-9][0-9][0-9]$)|(^[1-9][0-9][0-9][0-9]$)|(^[1-6][0-5][0-5][0-3][0-5]$)/");
        return pattern.matcher(matchString).matches();
    }

    /**
     * 使用java正则表达式去掉多余的.与0
     *
     * @param s
     * @return
     */
    public static String subZeroAndDot(String s) {
        if (isBlank(s)) {
            return "0";
        }
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉
        }
        return s;
    }

    /**
     * 去除字符串中的空格、回车、换行符、制表符
     *
     * @param str
     * @return
     */
    public static String replaceBlank(String str) {
        String dest = "";
        if (str != null) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }
        return dest;
    }

    /**
     * 替换多个连续的回车符
     *
     * @return
     */
    public static String replaceContinuousEnter(String str) {
        Pattern pattern = Pattern.compile("(\n)\\1+");
        //        Matcher matcher = pattern.matcher("111234445466");
        Matcher matcher = pattern.matcher(str);
        //sb 缓冲区作为存储替换后的结果
        StringBuffer sb = new StringBuffer();
        //用正则表达式的find函数去判断，有没有匹配的结果集
        while (matcher.find()) {
            //match.group(0) 是匹配的字符串，比如111234445466中的111
            //match.group(1) 是匹配的字符串的单个字符，比如111234445466中的111中的1
            String repeat = matcher.group(1);
            //appendReplacement用第二个参数去替换匹配成功的子串，并把结果存放在sb中，前面未匹配成功的也会放进去，后面的未匹配成功的不会放进去。例如：11123444546634 最后会替换成(1)23(4)54(6)
            matcher.appendReplacement(sb, repeat + repeat);
        }
        matcher.appendTail(sb);
        return sb.toString();
    }
}
